﻿using EGuayas.Web.Resources;
using EntGuayasSLA.BL;
using EntGuayasSLA.BL.Archivos.Pdf;
using EntGuayasSLA.BL.Listas;
using EntGuayasSLA.BL.Listas.Criterias;
using Ext.Net;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace EGuayas.Web.Auditoria
{
    /// <summary>
    /// Informe para auditoria monitoreo,pma,otros
    /// </summary>
    public partial class wucInformePmaMon : ucWuc
    {
        protected String ModuloSession
        {
            get
            {

                return ReadCustomConfig(this.pnlLoadDocu, this.ID, "_aud");
            }

        }
        protected String ValorFaseOrAuditoriaId
        {
            get
            {

                return (this.ModuloSession == Valores.Modulo_Archivo_Informes_Aud_Cump) ? GetSessionPage.GetSession(ReadCustomConfigFaseAuditoria(this.pnlLoadDocu, this.ID)) : ReadCustomConfigAuditoriaId(this.pnlLoadDocu, this.ID);
            }

        }
        protected String IdPageSession
        {
            get
            {
               
                return ReadCustomConfigPage(this.pnlLoadDocu, this.ID);
            }

        }
        public String ExpedienteId
        {
            get
            {
                return ReadCustomConfig(this.pnlLoadDocu, this.ID, "_AexpId");
            }
        }
        public String ExpedienteAuditoriaId
        {
            get
            {
                return ReadCustomConfigExpedienteAuditoria(this.pnlLoadDocu, this.ID);
            }
        }
        protected String CodigoEstadoFase
        {
            get
            {
                return ReadCustomConfigSessionCodigoFase(this.pnlLoadDocu, this.ID);
            }

        }
        protected String EstadoFase
        {
            get
            {

                return ReadCustomConfigEstadoFase(this.pnlLoadDocu, this.ID);
            }

        }
       
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                    if (!X.IsAjaxRequest)
                    {
                       string codigoDeFase = GetSessionPage.GetSession(this.CodigoEstadoFase);
                       string estadoDeFase = GetSessionPage.GetSession(this.EstadoFase);
                       this.hdEstadoPorRev.SetValue(Valores.Codigo_Estado_Inf_PorRevizar);
                       this.hdEstadoDir.SetValue(Valores.Codigo_Estado_Inf_RevDir);
                       this.hddCodigoRol.SetValue(GetSessionUsuario.UsuarioRolCodigo);
                       this.hdEstadoSubDir.SetValue(Valores.Codigo_Estado_Inf_RevSubDir);
                       this.stoCbxDirector.DataSource = DirectorSubDirLista.GetDirectorSubDirLista();
                       this.stoCbxDirector.DataBind();
                        //Llenar datos de resolución exepto en categorizacion
                       this.stoEstadosFases.DataSource = EstadoFaseLista.GetEstadoFase(codigoDeFase);
                       this.stoEstadosFases.DataBind();
                       //                     
                       if (ModuloSession == Valores.Modulo_Archivo_Informes_Aud_Cump)
                       {
                           FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                           this.hdFaseAudCump.SetValue(objFaseAud.CodigoFase);
                           //Plan de accion o seguimiento a pago anual
                           if (objFaseAud.CodigoFase == Constantes.APoliza || objFaseAud.CodigoFase == Constantes.AAuditoria)
                           {  
                               this.rdgSiNoApro.AllowBlank = false;                             
                               this.rdgSiNoApro.Show();
                           }
                           else
                           {
                               this.rdgSiNoApro.AllowBlank = true;
                               this.rdgSiNoApro.Hide();
                           }
                            if (objFaseAud.CodigoFase == Constantes.APoliza)
                           {
                               this.btnNextAudCump.Show();
                               this.btnNextAudCump.Disable();
                               this.rdgSiNoApro.FieldLabel = "Seguimiento pago anual";
                           }
                           else
                           {
                             
                               this.btnNextAudCump.Disable();
                               this.btnNextAudCump.Hide();
                           }
                       }
                       else
                       {
                           this.rdgSiNoApro.FieldLabel = "Plan de acción";
                           this.rdgSiNoApro.AllowBlank = false;
                           this.rdgSiNoApro.Show();
                           this.hdFaseAudCump.SetValue("");
                       }
             
                       Window winNoDoc = new Window()
                       {
                           ID     = "winDocVerNow",
                           Title  = "Documentos a Corregir",
                           Hidden = true, 
                           Height = Unit.Pixel(370),                      
                           Width  = Unit.Pixel(660),
                           ButtonAlign = Alignment.Center,
                           Closable    = false,
                           Maximized   = true,

                           Loader = new ComponentLoader
                           {
                      
                               Mode   = LoadMode.Frame,
                               Url = ConfigurationManager.AppSettings.Get("Url") + "Auditoria/admin/PgWucInforme.aspx?ModuloSession=" + ModuloSession + "&IdPageSession=" + IdPageSession + "&ValorFaseOrAuditoriaId=" + ValorFaseOrAuditoriaId + "&ExpedienteId=" + ExpedienteId + "&ExpedienteAuditoriaId=" + ExpedienteAuditoriaId + "&FaseCode=" + codigoDeFase,
                               LoadMask = 
                               { 
                                 ShowMask=true
                               }
                           }
                       };
                       Ext.Net.Button btnApply = new Ext.Net.Button();
                       btnApply.Text = "Aceptar";
                       btnApply.OnClientClick = "wucJsCorrInfDoc.CloseVentanaNoAceptar();";
                       winNoDoc.Buttons.Add(btnApply);
                       //App.btnLogin.fireEvent('click');
                       
                       this.Controls.Add(winNoDoc);

                       
                       //DESHABILITAR MODO LECTURA
                       if (GetSessionPage.GetSession(EstadoFase) == Valores.Codigo_Estado_Fase_Finalizado || GetSessionPage.GetSession(EstadoFase) == Valores.Codigo_Estado_Fase_Inicial)
                       {

                           RemoveEndColumnGridGlobal(5, this.gpDocumentosLoad);
                          this.btnForm.Disable();
                       }
                       else
                       {
                           this.btnForm.Enable();

                       }
                    }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.Page_Load" + ex);
            }
        }
              
        /// <summary>
        /// Datos de archivos de promotor
        /// </summary>
        /// <returns></returns>
        [DirectMethod(IDAlias = "WucLoadDoc")]
        public ArchivoLista BindData()
        {
            try
            {
                    ArchivoGlobalCriteria filter = ArchivoGlobalCriteria.NewArchivoGlobalCriteria();
                    //filter.ExpedienteId = ExpedienteId;// GetSessionPage.ExpedienteId(IdPageSession);
                    filter.ExpedienteId = "";
                    filter.FaseId = ValorFaseOrAuditoriaId;
                    filter.Tabla = ModuloSession;
                    return ArchivoLista.GetArchivoLista(filter);
             }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.BindData" + ex);
            }
            return null;
        }
        #region Expander Grid
        protected static void GrdInbox_Command(object sender, DirectEventArgs e)
        {
            /*
                string commandName = e.ExtraParams["command"];
                long Id = Convert.ToInt64(e.ExtraParams["Id"]);
            */
        }
        
        #endregion Expander Grid

        [DirectMethod(IDAlias = "WucLoadDoc")]
        public RtaFindConfigPA FindPlanAccion( string valTabla)
        {
            try
            {
                RtaFindConfigPA rta = new RtaFindConfigPA();
                
                switch (valTabla)
                {
                    case "INFDOCAUDMON":
                        {
                            AuditoriaMonitoreo monAudRoot = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (monAudRoot.MonitoreoIdAdd != "")
                            {
                                AuditoriaMonitoreo monAudNodo = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(monAudRoot.MonitoreoIdAdd));
                                rta.IdAudOtsNow = monAudNodo.Id.ToString();
                                rta.Titulo ="Resolución"+ monAudNodo.Alias;              
                            }
                            break;
                        }
                    case "INFDOCAUDPMA":
                        {
                            AuditoriaPMA audPmaRoot = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (audPmaRoot.PmaIdAdd != "")
                            {
                                AuditoriaPMA audPma = AuditoriaPMA.GetEditableRoot(Guid.Parse(audPmaRoot.PmaIdAdd));
                                rta.IdAudOtsNow = audPma.Id.ToString();
                                rta.Titulo = "Resolución" + audPma.Alias;       
                            }
                            break;
                        }
                    case "INFDOCAUDOTROS":
                        {
                            AuditoriaOtros audOtsRoot = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (audOtsRoot.OtrosIdAdd2 != "")
                            {
                                AuditoriaOtros audOts = AuditoriaOtros.GetEditableRoot(audOtsRoot.OtrosIdAdd2);
                                rta.IdAudOtsNow = audOts.Id.ToString();
                                rta.Titulo = "Resolución" + audOts.Alias;       
                            }
                            break;
                        }
                   
                }
                return (rta);
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.FindConfigPA" + ex);
            }
            return null;
        }
        
        [DirectMethod(IDAlias = "WucLoadDoc")]
        public RtaFindConfigPA FindConfigPA(string idAuditoria,string valMonOrPma)
        {
            try
            {   
                 RtaFindConfigPA rta = new RtaFindConfigPA();
                 AuditoriaOtros audOts = null;
                 switch(valMonOrPma)
                 {
                        case "INFDOCAUDMON":
                        {
                            AuditoriaMonitoreo monAud = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (monAud.OtrosIdAdd != "")
                            {
                                audOts = AuditoriaOtros.GetEditableRoot(monAud.OtrosIdAdd);
                                rta.IdAudOtsNow = audOts.Id.ToString();
                            }
                            break;
                        }
                        case "INFDOCAUDPMA":
                        {
                            AuditoriaPMA audPma = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (audPma.OtrosIdAdd != "")
                            {
                                audOts = AuditoriaOtros.GetEditableRoot(audPma.OtrosIdAdd);
                                rta.IdAudOtsNow = audOts.Id.ToString();
                            }
                            break;
                        }
                        case "INFDOCAUDOTROS":
                        {
                            AuditoriaOtros audOtsRoot = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                            if (audOtsRoot.OtrosIdAdd2 != "")
                            {
                                audOts = AuditoriaOtros.GetEditableRoot(audOtsRoot.OtrosIdAdd2);
                                rta.IdAudOtsNow = audOts.Id.ToString();
                            }
                            break;
                        }
                        case "INFDOCAUDCUM":
                        {
                             FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                             audOts = AuditoriaOtros.GetEditableRoot(idAuditoria);
                             rta.CodeFase = objFaseAud.CodigoFase;
                             if (objFaseAud.CodigoFase == Constantes.APoliza && audOts.Nombre == Valores.NombreOtrosSegPagAnual)
                             {
                                 rta.IdAudOtsNow = audOts.Id.ToString();

                             }
                             else
                             {

                                 if (objFaseAud.CodigoFase == Constantes.AAuditoria && audOts.Nombre == Valores.NombreOtrosPlandeAccion)
                                 {
                                     rta.IdAudOtsNow = audOts.Id.ToString();

                                 }
                             }
                             break;
                         }
                }
                return (rta);
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.FindConfigPA" + ex);
            }
            return null;
        }
       
        [DirectMethod(IDAlias = "WucLoadDoc")]
        public void DoNoInf(string PlanDeAccion, string Estado, Boolean valFlag)
        {
            try
            {
                    if (valFlag == false)
                    {
                         X.Msg.Show(new MessageBoxConfig
                        {
                            Buttons = MessageBox.Button.OK,
                            Icon = MessageBox.Icon.INFO,
                            Title = Titulos.TituloAviso,
                            Message = "Complete información en caso de seleccionar <b>'Plan de acción'</b> y/o la <b>'Resolución'</b> sea Aceptada"
                        });
                    }
                    else
                    {
                        this.winDocumento.Close();
                    }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.DoNoInf" + ex);
            }
        }

        [DirectMethod(IDAlias = "WucInforme")]
        public ListReturn ObtenerRevisor(string id)
        {
            try
            {
                ListReturn valReturn = new ListReturn();
                valReturn.ListaRev = RevisionFaseLista.GetRevisionFaseLista(id);
                RevisionFaseInfo rowInfo = valReturn.ListaRev.FirstOrDefault();
                valReturn.ListaDir = null;
                //Remover persona asignada
                if (rowInfo != null)
                {
                    valReturn.ListaDir = DirectorSubDirLista.GetDirectorSubDirLista(rowInfo.PersonaIdRevisor);

                }

                return valReturn;
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformeCorrecion.ObtenerRevisor::" + ex);

            }
            return null;
        }
        
        
        
        
        /// <summary>
        /// Verificar si se creo una auditoria asociada a otro auditoria y se desea cancelar, sin terminar el proceso
        /// </summary>
        /// <param name="PlanDeAccion"></param>
        /// <param name="Estado"></param>
        /// <param name="nInforme"></param>
        /// <returns></returns>
        private bool GetRequeridoPlanAccionOrAud(string PlanDeAccion, string Estado, int nInforme)
        {
            MaskConfig cfg = new MaskConfig();
            cfg.Msg = "Esperar ...";
            cfg.El = "Ext.getBody()";
            X.Mask.Show(cfg);
            Boolean valFlag = false;
            switch (ModuloSession)
            {

                case Valores.Modulo_Archivo_Informes_Aud_Moni:
                    AuditoriaMonitoreo monitoreo = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {
                        valFlag = (monitoreo.OtrosIdAdd != "");

                    }
                    else
                    {
                        valFlag = true;
                    }

                    if (valFlag)//Evaluar Estado en caso de que plan de accion = true
                    {
                        if (Estado == "ACE")
                        {

                            valFlag = (monitoreo.MonitoreoIdAdd != "");
                            
                        }
                        else
                        {
                            valFlag = true;
                        }
                    }
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Pma:
                    AuditoriaPMA audPma = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {
                        valFlag = (audPma.OtrosIdAdd != "");

                    }
                    else
                    {
                        valFlag = true;
                    }
                    if (valFlag)//Evaluar Estado en caso de que plan de accion = true
                    {
                        if (Estado == "ACE")
                        {

                            valFlag = (audPma.PmaIdAdd != "");
                        }
                        else
                        {
                            valFlag = true;
                        }
                    }
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Otro:
                    AuditoriaOtros audOtsRoot = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {
                        valFlag = (audOtsRoot.OtrosIdAdd2 != "");

                    }
                    else
                    {
                        valFlag = true;
                    }
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Cump:
                    FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    AuditoriaCumplimiento aud = AuditoriaCumplimiento.GetEditableRoot(Guid.Parse(objFaseAud.AuditoriaCumplimientoId));
                    AuditoriaOtros audOtsRootCump = AuditoriaOtros.GetEditableRoot(aud.ExpedienteAuditoriaId);
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si && nInforme == 0)
                    {
                        valFlag = (audOtsRootCump.ExpedienteAuditoriaId != "");

                    }
                    else
                    {
                        valFlag = true;
                    }
                    break;

            }
            X.Mask.Hide();
            return valFlag;
        }
        private void DeleteAuditoriaAsociadas(string PlanDeAccion, string Estado)
        {
            MaskConfig cfg = new MaskConfig();
            cfg.Msg = "Esperar ...";
            cfg.El = "Ext.getBody()";
            X.Mask.Show(cfg);

            switch (ModuloSession)
            {

                case Valores.Modulo_Archivo_Informes_Aud_Moni:
                    AuditoriaMonitoreo monitoreo = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {

                        if (monitoreo.OtrosIdAdd != "")
                        {
                            AuditoriaOtros otsDelMon = AuditoriaOtros.GetEditableRoot(Guid.Parse(monitoreo.OtrosIdAdd));
                            otsDelMon.Delete();
                            otsDelMon.Save();
                        }
                    }
                    if (Estado == "ACE")
                    {
                        if (monitoreo.MonitoreoIdAdd != "")
                        {
                            AuditoriaMonitoreo monDel = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(monitoreo.MonitoreoIdAdd));
                            monDel.Delete();
                            monDel.Save();
                        }
                    }
                    //Modificar en caso de condiciones se cumplan
                    if (((PlanDeAccion == Valores.Codigo_CHAR_Si) && (monitoreo.OtrosIdAdd != "")) || ((Estado == "ACE") && (monitoreo.MonitoreoIdAdd != "")))
                    {
                        monitoreo.OtrosIdAdd = "";
                        monitoreo.MonitoreoIdAdd = "";
                        monitoreo.Save();
                    }
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Pma:
                    AuditoriaPMA audPma = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {
                        if (audPma.OtrosIdAdd != "")
                        {
                            AuditoriaOtros otsDelPma = AuditoriaOtros.GetEditableRoot(Guid.Parse(audPma.OtrosIdAdd));
                            otsDelPma.Delete();
                            otsDelPma.Save();
                        }
                    }
                    if (Estado == "ACE")
                    {
                        if (audPma.PmaIdAdd != "")
                        {
                            AuditoriaPMA pmaDel = AuditoriaPMA.GetEditableRoot(Guid.Parse(audPma.PmaIdAdd));
                            pmaDel.Delete();
                            pmaDel.Save();
                        }
                    }
                    //Modificar en caso de condiciones se cumplan
                    if (((PlanDeAccion == Valores.Codigo_CHAR_Si) && (audPma.OtrosIdAdd != "")) || ((Estado == "ACE") && (audPma.PmaIdAdd != "")))
                    {
                        audPma.OtrosIdAdd = "";
                        audPma.PmaIdAdd = "";
                        audPma.Save();
                    }

                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Otro:
                    AuditoriaOtros audOtsRoot = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si)
                    {
                        if (audOtsRoot.OtrosIdAdd2 != "")
                        {
                            AuditoriaOtros otsDelPma = AuditoriaOtros.GetEditableRoot(Guid.Parse(audOtsRoot.OtrosIdAdd2));
                            otsDelPma.Delete();
                            otsDelPma.Save();
                        }
                    }
                    //Modificar en caso de condiciones se cumplan
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si && audOtsRoot.OtrosIdAdd2 != "")
                    {
                        audOtsRoot.OtrosIdAdd1 = "";
                        audOtsRoot.Save();
                    }

                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Cump:
                    FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                    AuditoriaCumplimiento aud = AuditoriaCumplimiento.GetEditableRoot(Guid.Parse(objFaseAud.AuditoriaCumplimientoId));
                    AuditoriaOtros audOtsRootCump = AuditoriaOtros.GetEditableRoot(aud.ExpedienteAuditoriaId);
                    int nCountAud = 0;
                    //Solo se puede crear una aditoria otros en informe de cumplimiento validación
                    if (audOtsRootCump.ExpedienteAuditoriaId != "")
                    {
                        AuditoriaOtrosLista audlistaots = AuditoriaOtrosLista.GetAuditoriaOtrosLista(Guid.Parse(audOtsRootCump.ExpedienteAuditoriaId));
                        nCountAud = audlistaots.Count;
                    }
                    if (PlanDeAccion == Valores.Codigo_CHAR_Si && nCountAud < 2)
                    {
                        audOtsRootCump.Delete();
                        audOtsRootCump.Save();

                    }
                    break;

            }
            X.Mask.Hide();
        }
        [DirectMethod(IDAlias = "WucLoadDoc")]
        public void DoYesInf(string PlanDeAccion, string Estado)
        {
            try
            {
                DeleteAuditoriaAsociadas(PlanDeAccion, Estado);
                this.winDocumento.Close();
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.DoYesInf" + ex);
            }
                       
        }            
        protected void btnCancelarInf_Click(object sender, DirectEventArgs e)
        {
            try
            {
                Boolean ifConfirm = true;
                if (ModuloSession == Valores.Modulo_Archivo_Informes_Aud_Cump)
                {
                    FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));

                    if (objFaseAud.CodigoFase == Constantes.APoliza && this.btnNextAudCump.Enabled)
                    {
                        ifConfirm = false;
                    }
                }
                if (ifConfirm)
                {
                    int nInforme = 0;
                    int.TryParse(e.ExtraParams["CountInforme"], out nInforme);
                    ifConfirm = GetRequeridoPlanAccionOrAud(e.ExtraParams["PlanDeAccion"], e.ExtraParams["Estado"], nInforme);
                    if (ifConfirm)
                    {
                        X.Msg.Confirm("Aviso", "Previamente se creo pasos para crear informe, desea borrar cambios antes de cerrar ventana.", new MessageBoxButtonsConfig
                        {
                            Yes = new MessageBoxButtonConfig
                            {
                                Handler = "App.direct.WucLoadDoc.DoYesInf('" + e.ExtraParams["PlanDeAccion"] + "','" + e.ExtraParams["Estado"] + "')",
                                Text = "Si"
                            },
                            No = new MessageBoxButtonConfig
                            {
                                //Handler = "App.direct.WucLoadDoc.DoNoInf('" + e.ExtraParams["PlanDeAccion"] + "','" + e.ExtraParams["Estado"] + "')",
                                Text = "No"
                            }
                        }).Show();
                    }
                    else
                    {
                        this.winDocumento.Close();                    
                    }
                }
                else
                {
                    this.winDocumento.Close();
                }

              
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.btnCancelarInf_Click" + ex);
            }
        }
        /// <summary>
        /// Subir archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void UploadClick(object sender, DirectEventArgs e)
        {
            try
            {
                     FaseAuditoria objFaseAud = FaseAuditoria.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                     //Asignar valor del estado a cada auditoria
                     switch (ModuloSession)
                     {

                         case Valores.Modulo_Archivo_Informes_Aud_Cump:
                           
                             objFaseAud.EstadoDMA = e.ExtraParams["hdEstado"];
                             objFaseAud.Save();
                             if (objFaseAud.CodigoFase == Constantes.APoliza)
                             {
                                 this.btnNextAudCump.Enable();
                             }
                             //Plan de acción de auditoria de cumplimiento
                             if (Session[Constantes.AChildPlanAccionCump] != null)
                             {
                                 AuditoriaCumplimiento audCump = AuditoriaCumplimiento.GetEditableRoot(Guid.Parse(objFaseAud.AuditoriaCumplimientoId));
                                 AuditoriaOtros cumpOtsPlanAccion = (AuditoriaOtros)Session[Constantes.AChildPlanAccionCump];
                                 cumpOtsPlanAccion.Nombre = GetNameParentAlias(audCump.Alias + "-" + objFaseAud.Nombre) + "/" +GetNameParentAlias( cumpOtsPlanAccion.Nombre);
                                 cumpOtsPlanAccion.Save();
                                 cumpOtsPlanAccion.CumpliIdAdd = objFaseAud.AuditoriaCumplimientoId;
                                 Session[Constantes.AChildPlanAccionCump] = null;
                             }
                             break;

                         case Valores.Modulo_Archivo_Informes_Aud_Moni:
                             AuditoriaMonitoreo monitoreoRoot = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                             monitoreoRoot.EstadoDMA = e.ExtraParams["hdEstado"];
                             //Crear monitoreo adicional
                             if (Session[Constantes.AChildMonitoreo] != null)
                             {
                                 AuditoriaMonitoreo monitoreoChild = (AuditoriaMonitoreo)Session[Constantes.AChildMonitoreo];
                                 if (monitoreoChild.Alias == "")
                                     monitoreoChild.Alias = "Resolución de " + GetNameParentAlias(monitoreoRoot.Alias);
                                 else
                                     monitoreoChild.Alias = "Resolución de " + GetNameParentAlias(monitoreoRoot.Alias) + "/" + GetNameParentAlias(monitoreoChild.Alias);
                                 monitoreoChild.MonitoreoIdAdd = "";
                                 monitoreoChild.Save();
                                 monitoreoRoot.MonitoreoIdAdd = monitoreoChild.Id.ToString();
                                 Session[Constantes.AChildMonitoreo] = null;
                             }
                             if (Session[Constantes.AChildPlanAccionMonitoreo] != null)
                             {
                                 AuditoriaOtros monitoreoOtsPlanAccion = (AuditoriaOtros)Session[Constantes.AChildPlanAccionMonitoreo];
                                 if (monitoreoRoot.Alias != "")
                                     monitoreoOtsPlanAccion.Nombre = monitoreoOtsPlanAccion.Nombre + "/" +GetNameParentAlias( monitoreoRoot.Alias);
                                 monitoreoOtsPlanAccion.Save();
                                 monitoreoRoot.OtrosIdAdd = monitoreoOtsPlanAccion.Id.ToString();
                                 Session[Constantes.AChildPlanAccionMonitoreo] = null;
                             }
                             monitoreoRoot.Save();
                             break;
                         case Valores.Modulo_Archivo_Informes_Aud_Pma:
                             AuditoriaPMA pmaAudRoot = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                             pmaAudRoot.EstadoDMA = e.ExtraParams["hdEstado"];
                             //Crear pma adicional
                             if (Session[Constantes.AChildPMA] != null)
                             {
                                 AuditoriaPMA pmaChild = (AuditoriaPMA)Session[Constantes.AChildPMA];
                                 if (pmaChild.Alias == "")
                                     pmaChild.Alias = "Resolución de " + GetNameParentAlias(pmaAudRoot.Alias);
                                 else
                                     pmaChild.Alias = "Resolución de " + GetNameParentAlias(pmaAudRoot.Alias) + "/" + GetNameParentAlias(pmaChild.Alias);
                                 pmaChild.PmaIdAdd = "";
                                 pmaChild.Save();
                                 pmaAudRoot.PmaIdAdd = pmaChild.Id.ToString();
                                 Session[Constantes.AChildPMA] = null;
                             }
                             if (Session[Constantes.AChildPlanAccionPMA] != null)
                             {
                                 AuditoriaOtros pmaOtsPlanAccion = (AuditoriaOtros)Session[Constantes.AChildPlanAccionPMA];
                                 if (pmaAudRoot.Alias != "")
                                     pmaOtsPlanAccion.Nombre = pmaOtsPlanAccion.Nombre + "/" + GetNameParentAlias(pmaAudRoot.Alias);
                                 pmaOtsPlanAccion.Save();
                                 pmaAudRoot.OtrosIdAdd = pmaOtsPlanAccion.Id.ToString();
                                 Session[Constantes.AChildPlanAccionPMA] = null;
                             }
                             pmaAudRoot.Save();
                             break;
                         case Valores.Modulo_Archivo_Informes_Aud_Otro:
                             AuditoriaOtros otrosaudRoot = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValorFaseOrAuditoriaId));
                             otrosaudRoot.EstadoDMA = e.ExtraParams["hdEstado"];
                             //Crear otros adicional
                             if (Session[Constantes.AChildOtros] != null)
                             {
                                 AuditoriaOtros otsChild = (AuditoriaOtros)Session[Constantes.AChildOtros];
                                 if (otrosaudRoot.Alias != "")
                                     otsChild.Nombre = otsChild.Nombre + "/" + GetNameParentAlias(otrosaudRoot.Alias);
                                 otsChild.OtrosIdAdd1 = "";
                                 otsChild.Save();
                                 otrosaudRoot.OtrosIdAdd1 = otsChild.Id.ToString();
                                 Session[Constantes.AChildOtros] = null;
                             }
                             otrosaudRoot.Save();
                             break;
                     }
                     //Documento adicionales de auditoria otros
                     if (Session[Constantes.AChildDocOtros] != null)
                     {
                         List<DocumentoAdicional> listObjAdd = (List<DocumentoAdicional>)Session[Constantes.AChildDocOtros];
                         foreach (DocumentoAdicional itemDocAdd in listObjAdd) //
                         {
                             itemDocAdd.Save();
                         }
                         Session[Constantes.AChildDocOtros] = null;
                     }
                     //Documentos en estado NO ACEPTADO
                     string codigoDeFase = GetSessionPage.GetSession(this.CodigoEstadoFase);
                     //Caso de selecionar estado aceptado
                     if (e.ExtraParams["hdEstado"] == Valores.EstadoAceptado)
                     {
                         Session[Constantes.AListaDocumentos + codigoDeFase] = null;
                         Session[Constantes.AListaArchivosAdd + codigoDeFase] = null;
                     }
                     if (Session[Constantes.AListaDocumentos + codigoDeFase] != null)
                     {
                         string gridJson = Session[Constantes.AListaDocumentos + codigoDeFase].ToString();
                         Dictionary<string, string>[] gridData = JSON.Deserialize<Dictionary<string, string>[]>(gridJson);                   
                         int i = 0;
                         string nameTable = ModuloSession.Replace("INF", "");
                         while (i < gridData.Length)
                         {
                             var val1 = gridData[i];

                             Archivo arch = Archivo.GetEditableRoot(Guid.Parse(val1["Id"]), nameTable);
                             arch.SubirNuevo = val1["SubirNuevo"];
                             arch.Save();
                             i += 1;
                         }
                         Session[Constantes.AListaDocumentos + codigoDeFase] = null;
                     }
                     if (Session[Constantes.AListaArchivosAdd + codigoDeFase] != null)
                     {
                         string json = Session[Constantes.AListaArchivosAdd + codigoDeFase].ToString();
                         Dictionary<string, string>[] listItems = JSON.Deserialize<Dictionary<string, string>[]>(json);

                         foreach (Dictionary<string, string> row in listItems)
                         {
                             Boolean ifAdd = true;
                             Boolean.TryParse(row["Nuevo"], out ifAdd);
                             if (ifAdd == true)
                             {

                                 DocumentoAdicional objDocAdd = DocumentoAdicional.NewEditableRoot();
                                 objDocAdd.Id = System.Guid.NewGuid();

                                 objDocAdd.Nombre = row["Nombre"];
                                 objDocAdd.Formato = row["Formato"];
                                 objDocAdd.Obligatorio = Valores.Codigo_CHAR_Si;

                                 objDocAdd.Modulo = ModuloSession;
                                 objDocAdd.IdModulo = ValorFaseOrAuditoriaId;
                                 objDocAdd.Save();
                             }
                         }
                         Session[Constantes.AListaArchivosAdd + codigoDeFase] = null;
                     }

                     //Proceso de subir informe
                     FileUploadField myCtlFileUp = (FileUploadField)this.FindControl("FileUploadDocUpInf");
                     if (myCtlFileUp.HasFile)
                     {
                         Boolean IfNewVer = Convert.ToBoolean(e.ExtraParams["hddnDocIfVer"]);
                         int version = 0;
                         string fileExt = myCtlFileUp.PostedFile.FileName.Substring(myCtlFileUp.PostedFile.FileName.LastIndexOf('.') + 1);
                         string ruta = "";
                         string fileName = "";
                         string fileNameTmp = "";

                         Int32.TryParse(e.ExtraParams["hddnDocUpVers"], out version);
                         this.GetNameFile(myCtlFileUp, fileExt, ref ruta, ref fileName, ref fileNameTmp);

                         //TODO:Generar User id para descriptar y encriptar                
                         //Guid guid = Guid.NewGuid();

                         byte[] USER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("UserPdf"));
                         byte[] OWNER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("PwdPdf"));

                         if (fileExt.ToLower() == "pdf")
                         {
                             myCtlFileUp.PostedFile.SaveAs(fileNameTmp);
                             Pdf.EncryptFilePdf(fileNameTmp, fileName, USER, OWNER);
                             File.Delete(fileNameTmp);
                         }
                         else
                         {
                             myCtlFileUp.PostedFile.SaveAs(fileName);
                         }
                         string tpl = Mensajes.MensajeArchivoCorrecto;

                         Archivo objArch = Archivo.NewEditableRoot(ModuloSession);
                         objArch.Id = System.Guid.NewGuid();
                         //Nuevas versiones datos correguidos
                         objArch.SubirNuevo = "C";
                         if (version == 1)
                         {
                             objArch.SubirNuevo = "N";
                             objArch.Referencia = objArch.Id.ToString();
                         }
                         else
                             if (version == 2)
                                 objArch.Referencia = e.ExtraParams["hddnDocUpId"];
                             else
                                 if (version > 2)
                                     objArch.Referencia = e.ExtraParams["hddnDocUpRef"];

                         objArch.Nombre = e.ExtraParams["txtNombre"];
                         objArch.Descripcion = e.ExtraParams["txtDesp"];
                         objArch.FechaCreacion = DateTime.Now;
                         objArch.RequiereFirmar = "N";
                         objArch.Firmado = "N";
                         objArch.TipoDocumento = "Informe";

                         objArch.Version = version;
                         objArch.RequiereFirmar = "N";

                         objArch.PersonaId = GetSessionUsuario.PersonaId;
                         objArch.GlobalRelacionId = ValorFaseOrAuditoriaId;
                         objArch.CodigoFase = GetSessionPage.GetSession(CodigoEstadoFase);
                         objArch.ExpedienteId = ExpedienteId;
                         objArch.Ruta = ruta;
                         objArch.Save();

                         //Inicialmente Tecnico sube informe con estado POR-REVIZAR
                         UpdateEstadoInfome(objArch.Id, Valores.Codigo_Estado_Inf_PorRevizar);

                         //
                         //Guardar id archivos temporalmente recien creados
                         ExtNet.Js.Call("wucJsLoadCor.AddIdsNew", objArch.Id.ToString(), objArch.Version.ToString());
                         gpDocumentosLoad.GetStore().Reload();
                         X.Msg.Show(new MessageBoxConfig
                         {
                             Buttons = MessageBox.Button.OK,
                             Icon = MessageBox.Icon.INFO,
                             Title = Titulos.TituloAviso,
                             Message = string.Format(tpl, myCtlFileUp.PostedFile.FileName)
                         });
                         //En el caso de poliza
                         if (ModuloSession == Valores.Modulo_Archivo_Informes_Aud_Cump && objFaseAud.CodigoFase == Constantes.APoliza)
                         {
                             
                             btnWinDocOk.Disable();
                         }
                         else
                         { 
                         winDocumento.Hide();
                         
                         }
                     }
                     else
                     {
                         X.Msg.Show(new MessageBoxConfig
                         {
                             Buttons = MessageBox.Button.OK,
                             Icon = MessageBox.Icon.ERROR,
                             Title = Titulos.TituloAviso,
                             Message = Mensajes.MensajeArchivoIncorrecto
                         });
                     }
                 
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.UploadClick" + ex);
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.ERROR,
                    Title = Titulos.TituloAviso,
                    Message = Mensajes.MensajeArchivoIncorrecto
                });
            }
        }

        private static string GetNameParentAlias(string nmAlias)
        {
            if (nmAlias != "")
            {
                int indesp = nmAlias.LastIndexOf("/");
                if (indesp != -1)
                {
                    nmAlias = nmAlias.Substring(indesp + 1);
                    nmAlias = nmAlias.Replace("Resolución de ", "");
                }
            }
            return nmAlias;
        }

        private  void UpdateEstadoInfome(Guid idArch,string _estado)
        {

            try
            {
                Informe objInforme = Informe.GetEditableRoot(idArch);
                objInforme.Estado = _estado;
                objInforme.Save();
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.UpdateEstadoInfome" + ex);
            }
           
        }
        /// <summary>
        /// Eliminar archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>     
        protected void btnDocUpEliminar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var id = Guid.Parse(e.ExtraParams["hddArchDelId"]);
                DeleteAuditoriaAsociadas(e.ExtraParams["PlanDeAccion"], e.ExtraParams["Estado"]);
                Archivo objArch = Archivo.GetEditableRoot(id, ModuloSession);
                DeleteFile(objArch.Ruta);                
                objArch.Delete();
                objArch.Save();                
                gpDocumentosLoad.GetStore().Reload();
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.btnDocUpEliminar_Click" + ex);
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="file"></param>
        private void DeleteFile(string file)
        {
            try
            {
            var path = Server.MapPath(file);
            if (System.IO.File.Exists(path))
                File.Delete(path);
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.DeleteFile" + ex);
            }
          
        }

        protected void btnComentarioInf_Click(object sender, DirectEventArgs e)
        {
            try
            {
                Guid id = Guid.Parse(e.ExtraParams["Id"]);
                Archivo objArch = Archivo.GetEditableRoot(id, ModuloSession);
                objArch.SubirNuevo = e.ExtraParams["Revizar"];
                objArch.Comentarios = e.ExtraParams["Comentarios"];
                //RegistrarLog(objArch.ToString()); Test try-catch
                objArch.Save();
                gpDocumentosLoad.GetStore().Reload();
                //X.Msg.Show(new MessageBoxConfig
                //{
                //    Buttons = MessageBox.Button.OK,
                //    Icon = MessageBox.Icon.INFO,
                //    Title = "Success",
                //    Message = string.Format("{0}<br/>", "Archivo asignado a revisión")
                //});
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.btnComentarioInf_Click" + ex);
            }

        }
        protected void Notifica_Command(object sender, DirectEventArgs e)
        {
            try
            {
                var informe = Informe.GetEditableRoot(Guid.Parse(e.ExtraParams["Id"]));
                informe.PersonaId = GetSessionUsuario.PersonaId;
                informe.Notifica = Valores.Codigo_CHAR_Si;
                informe.Estado = Valores.Codigo_Estado_Inf_Notificado;
                informe.TablaId   = e.ExtraParams["FaseLicId"];
                informe.Save();
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.INFO,
                    Title = Titulos.TituloAviso,
                    Message = "Informe notificado a Promotor"
                });
            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.Notifica_Command" + ex);
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.ERROR,
                    Title = Titulos.TituloAviso,
                    Message = "Ocurrio un error vuelva a intentar"
                });
            }
        }

        protected void btnGuardarRevizar_Click(object sender, DirectEventArgs e)
        {
            try
            {                
                //Crear Revision Fase y actualizar estado a director-subidirector
                string _stado = (e.ExtraParams["hddIdRol"] == Valores.Codigo_Rol_Director) ? Valores.Codigo_Estado_Inf_RevDir : Valores.Codigo_Estado_Inf_RevSubDir;
                RevisionFase objRevFase = RevisionFase.NewEditableRoot();
                objRevFase.Id = Guid.NewGuid();
                objRevFase.PersonaId = GetSessionUsuario.PersonaId;
                objRevFase.RevisorId = e.ExtraParams["ddfDirector"];
                objRevFase.Informe = e.ExtraParams["hddIdInforme"];
                objRevFase.Fecha = DateTime.Now;
                objRevFase.Aprobado = Valores.Codigo_CHAR_Revizar;
                objRevFase.TipoId = _stado;
                objRevFase.Save();
                UpdateEstadoInfome(Guid.Parse(e.ExtraParams["hddIdArchivo"]), _stado);
                gpDocumentosLoad.GetStore().Reload();
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.INFO,
                    Title = Titulos.TituloAviso,
                    Message = "Revisión creada"
                });                

            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformePmaMon.btnGuardarRevizar_Click" + ex);
            }
        }
        protected void btnGuardarReasignar_Click(object sender, DirectEventArgs e)
        {
            try
            {

                //Crear Revision Fase y actualizar estado a director-subidirector
                string _stado = (e.ExtraParams["hddIdRol"] == Valores.Codigo_Rol_Director) ? Valores.Codigo_Estado_Inf_RevDir : Valores.Codigo_Estado_Inf_RevSubDir;
                RevisionFase objRevFase = RevisionFase.GetEditableRoot(Guid.Parse(e.ExtraParams["hddIdRevicion"]));
                objRevFase.RevisorId = e.ExtraParams["ddfDirector"];
                objRevFase.Informe = e.ExtraParams["hddIdInforme"];
                objRevFase.Fecha = DateTime.Now;
                objRevFase.Aprobado = Valores.Codigo_CHAR_Revizar;
                objRevFase.TipoId = _stado;
                objRevFase.Save();
                UpdateEstadoInfome(Guid.Parse(e.ExtraParams["hddIdArchivo"]), _stado);
                gpDocumentosLoad.GetStore().Reload();
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon = MessageBox.Icon.INFO,
                    Title = Titulos.TituloAviso,
                    Message = "Revisión reasignada"
                });

            }
            catch (Exception ex)
            {
                RegistrarLog("wucInformeCorrecion.btnGuardarReasignar_Click::" + ex);
            }
        }
        /// <summary>
        /// Bind de comentarios de archivo
        /// </summary>
        /// <param name="action"></param>
        /// <param name="extraParams"></param>
        /// <returns></returns>
        [DirectMethod(IDAlias = "wucPlusCmt")]
        public ComentariosLista BindDataComentarios(string action, Dictionary<string, object> extraParams)
        {
            try
            {
                string queryPrm = extraParams.ContainsKey("idArchivo") ? extraParams["idArchivo"].ToString() : "";
                if (queryPrm != "")
                {
                    return ComentariosLista.GetComentariosLista(queryPrm);
                }
                return null;
            }
            catch (Exception ex)
            {
                RegistrarLog("wucOtros.BindDataAddArchivos" + ex);
            }
            return null;

        }
        public class ListReturn
        {
            public RevisionFaseLista ListaRev = null;
            public DirectorSubDirLista ListaDir = null;
            public ListReturn() { }
        }
        public class RtaFindConfigPA
        {
            public string IdAudOtsNow;
            public string CodeFase;
            public string Titulo;
            public RtaFindConfigPA()
            {
                IdAudOtsNow = "";
                CodeFase = "";
                Titulo = "";
            }
        }
    }
}